package ngramencoding;

import java.io.*;
import java.util.*;
import javax.swing.JFileChooser;
import org.biojava.bio.*;
import org.biojava.bio.seq.*;
import org.biojava.bio.seq.io.*;

/** ============================================================================
 * A classe LerFasta lê um arquivo *.fasta que contém as seqüências de nucleotídeos (atcg...)
 * e gera para cadas seqüência um arquivo *.seq com a "tradução" das representações <atcg...>
 * em <adenine thymine citosine guanine...>.
 * nome_arquivo.fasta ==> nome_arquivo.seq
 * @author Susan Higashi
 */
// ===============================================================================
public class FastaReader
{
        private File startingDir = new File("/home/su/Desktop/teste/1_fasta/");
        Utilities utilFl = new Utilities(); 
        private List <File> files;
    
    	/**
	 * 
	 */
        private List lista = new LinkedList();
	/**
	 * Arquivo de entrada em formato FASTA.
	 */
	private File arquivo; 
	/**
	 * Diretório de destino dos arquivo .seq.
	 */
	private File dirDestino;
        /**
         * Seqüência de nucleotídeos (A, T, C, G).
         */
        private String sequencia[];
        /**
         * Anotacoes da sequencia de nucleotideos.
         */        
        Annotation a;
        /**
         * Diretorio de saida dos arquivos .seq
         */
        File outputDir;
        
        /** --------------------------------------------------------------------
         * Seta o atributo sequencia com uma seqüência passada por parâmetro (seq[]).
         * @param seq Seqüência de nucleotídeos.
         */
        public void setSequencia(String seq[]){ sequencia = seq; }
        
        /** --------------------------------------------------------------------
         * Retorna a seqüência de nucleotídeos.
         * @return retorna a seqüência.
         */
        public String[] getSequencia(){ return sequencia; }
        
        /** --------------------------------------------------------------------
         * Seta o atributo a com uma anotacao passada por parâmetro (seq[]).
         * @param z anotacao sobre referente a sequencia de nucleotideos.
         */
        public void setAnnotation(Annotation z) { a = z; }
        
        /** --------------------------------------------------------------------
         * Retorna a anotacao referente a sequencia de nucleotideos.
         * @return retorna a anotacao.
         */        
        public Annotation getAnnotation() { return a; }
        
        /** ------------------------------------------------------------------------
         * 
         */
        void setOutputDir(String outputDirPath)
        {
            this.outputDir = new File(outputDirPath);  
        }
    
	/** --------------------------------------------------------------------
	 * Seleciona o arquivo de entrada com a(s) seqüência(s) de nucleotídeos
         * e o diretório de destino dos arquivos .seq (contém a seqüência de nucleotídeos).
	 */         
	public void definirArquivos()
        {
            try 
            {
                files = utilFl.getFileListing(startingDir);
            }
            catch(FileNotFoundException e)
            {   
                e.printStackTrace();
            }

            //SELECAO DO DIRETORIO DE DESTINO
            // diretorio de saida do arquivo de entrada das RN
            String outputDirPath = "/mnt/files/artigo/dev/trunk/ngramencoding/data/2-seq/bradyrhizobium-57/";
            setOutputDir(outputDirPath);
	}
        
        /** --------------------------------------------------------------------
	 * Utiliza a classe biojava para ler um arquivo no formato FASTA. Invoca demais 
	 * métodos necessários para realizar o processamento.
	 */
	public void lerArquivo()
        { 
            try 
            {
                for (File file : files) 
                {
                    BufferedReader arqFasta = new BufferedReader(new FileReader(file));//arquivo Fasta
                    SequenceIterator seqIt = SeqIOTools.readFastaDNA(arqFasta);           //le o arquivo fasta com as sequencias

                    //Realiza as operacoes para todas as cadeias.
                    while (seqIt.hasNext()) 
                    {
                        Sequence seq = seqIt.nextSequence();
                        String sequencia[] = new String[seq.length()];

                        for (int i = 0; i <  seq.length(); i++) //??
                        {
                            sequencia[i] = seq.symbolAt(i+1).getName();
                        }             

                        setSequencia(sequencia);

                        int idIncio = 3;
                        int idFim = seq.getName().substring(idIncio).indexOf("|gb");//12
                        if (idFim == -1)
                        {
                            idFim = seq.getName().substring(idIncio).indexOf("|");  //12
                        }

                        String nomeSeq = "gi_";
                        nomeSeq = nomeSeq.concat(seq.getName().substring(idIncio, idIncio+idFim));

                        lista.add(nomeSeq);

                        try { gravarArquivo(getSequencia(), nomeSeq, outputDir.getPath()); }
                        catch (IOException e) { e.printStackTrace(); }
                    }
                } 
            } 
            catch (BioException ex) { ex.printStackTrace(); }               //not in fasta format or wrong alphabet
            catch (NoSuchElementException ex) { ex.printStackTrace(); }     //no fasta sequences in the file
            catch (FileNotFoundException ex) { ex.printStackTrace(); }      //problem reading file
        }           
        
        /** --------------------------------------------------------------------
         * 
         */
        public void comparaSeq() throws IOException
        {
            BufferedWriter arqW = null;
            File arq = null;
            arq = new File("entradas_repetidas.txt");
            arqW = new BufferedWriter(new FileWriter(arq));
            
            if (arq.exists()) arq.delete();
            
            for (int i=0; i < lista.size(); i++)
            {   
                for (int j=0; j < lista.size(); j++)
                {
                    if(i == j)
                    {
                        break;
                    }
                    
                    if (lista.get(i).equals(lista.get(j)))
                    {
                        arqW.write(lista.get(i).toString().substring(3)+"\n");
                        arqW.flush();
                    }
                }
            }
            arqW.close();
        }
        
	/** --------------------------------------------------------------------
	 * Grava uma seqüência de nucleotídeos em um arquivo .seq.
 	 * @param s[] seqüência de nucleotídeos.
	 * @param nomeSeq nome da seqüência. Neste caso é o ?????????código de identificação 
	 * da proteína.
         * @param destino diretório de destino das seqüênias (arquivos .seq)
	 */
	private void gravarArquivo(String s[], String nomeSeq, String destino) throws IOException 
        {	
            Utilities  utilOs = new Utilities();
            String os = utilOs.getOS();

            String seq[];

            BufferedWriter arqE = null;
            File arquivo = null;

            //cria novo arquivo .seq
            if (os.equals("windows")) arquivo = new File (destino + "\\" +nomeSeq+".seq");
            else arquivo = new File (destino + "/" +nomeSeq+".seq");

            if (arquivo.exists()) arquivo.delete();		//se o arquivo ja existir apaga-o e cria-o novamente (sobreescreve)

            arqE = new BufferedWriter(new FileWriter(arquivo));	//arqE = Arquivo de escrita
            
            for (int j=0; j < getSequencia().length; j++)
            {
                arqE.write(getSequencia()[j] + " ");
                arqE.flush();
            }
            arqE.close();
	}     
}